package com.skydroid.demo.ui.activity

import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import com.skydroid.demo.R
import com.skydroid.demo.utils.LogUtils
import com.skydroid.demo.utils.String2ByteArrayUtils
import java.lang.StringBuilder
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress

/**
 * 调试类
 */
class TestActivity: AppCompatActivity()  {

    private val TAG = TestActivity::class.java.name

    private var datagramSocket : DatagramSocket? = null

    private var datagramSocket2 : DatagramSocket? = null

    private var  isCheck = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test)
        initView()
    }

    companion object{
        fun start(context: Context){
            context.startActivity(Intent(context,TestActivity::class.java))
        }
    }

    private fun initView(){
        findViewById<View>(R.id.btn_camera_check).setOnClickListener {
            Thread{
                connect13551()
            }.start()
        }
        findViewById<View>(R.id.btn_reset).setOnClickListener {
            Thread{
                connect14551()
            }.start()
        }
    }

    //region 摄像头校验
    private fun connect13551(){
        try {
            datagramSocket =  DatagramSocket(13551)
            datagramSocket?.connect(InetAddress.getByName("127.0.0.1"), 13552)
        } catch (e: Exception) {
            e.printStackTrace()
        }
        read13551()
    }

    private fun read13551(){
        try {
            while (datagramSocket != null) {
                var cache = ByteArray(256)
                var packet = DatagramPacket(cache , cache.size)
                datagramSocket?.receive(packet)
                //packet.length 是读取到的包长度
                var tempArray = ByteArray(packet.length)
                System.arraycopy( packet.data,0,tempArray,0,packet.length)
                Log.e(TAG,"收到：${String2ByteArrayUtils.bytes2Hex(tempArray)}")
                if(isCheck){
                    dealVideo(tempArray)
                }
            }
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }


    /**
     * 恢复加密摄像头摄像头
     */
    private fun dealVideo(datas:ByteArray){
        var bytes2Hex = String2ByteArrayUtils.bytes2Hex(datas)
        var headHex = String2ByteArrayUtils.bytes2Hex("AT+FENG -e".toByteArray())
        var end = String2ByteArrayUtils.bytes2Hex("\r\n".toByteArray())
        if(bytes2Hex!!.contains(headHex!!)){
            var s = bytes2Hex.substring(bytes2Hex!!.indexOf(headHex) + headHex!!.length,bytes2Hex!!.indexOf(end!!))
            LogUtils.test("x = $s")
            LogUtils.test("x = ${s.toInt(16)}")
            LogUtils.test("x h = ${(s.toInt(16) ushr 16).toString(16)}")
            LogUtils.test("x l = ${(s.toInt(16) and 0xFFFF).toString(16)}")

            var x = s.toInt(16)
            var y=(( x+1308888)*2018+1596056) xor x
            LogUtils.test("y = $y")
            LogUtils.test("y h = ${(y ushr 16).toString(16)}")
            LogUtils.test("y l = ${(y and 0xFFFF).toString(16)}")

            var sendHex = StringBuilder()
            sendHex.append(headHex)
                .append((y ushr 16).toString(16))
                .append((y and 0xFFFF).toString(16))
                .append(end)
            Log.e(TAG,"原始数据：${String2ByteArrayUtils.hex2Bytes(sendHex.toString())}")
            send(String2ByteArrayUtils.hex2Bytes(sendHex.toString()))
        }
    }

    private fun send(datas:ByteArray?){
        try {
            var packet = DatagramPacket( ByteArray(256), 256)
            packet.data = datas
            datagramSocket?.send(packet)

            Log.e(TAG,"发送：${String2ByteArrayUtils.bytes2Hex(packet.data)}")
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }
    //endregion

    //region 根据编号重发
    /**
    1.将数据缓存到 数组里
    2.判断 数组长度 是否大于256。 小于256 继续等待数据  大于256
    3.首先寻找 头部  AT+N 判断有几个
    3.1 只有一个 直接跳过 250字节   查找\r\n
    找到：完整包 将数据从数组移除
    未找到：错误包  重发。 移除数据  这时候 应该有2个错误包
    3.2 查找到2个
    3.2.1这时候第一个包肯定是不完整的  所以进行重发  并且移除数据
    移除后判断是否大于256  不大于 继续等待数据 大于256进行 3.2判断
     */

    //缓存数组长度
    private var cacheByteArrayLength = 1024

    //当前缓存到数组 index
    private var cacheByteArrayIndex = 0

    //缓存数组
    private var cacheByteArray = ByteArray(cacheByteArrayLength)

    //指令头
    private var headStr = "AT+"

    //每个完整数据包长度
    private var packageLength = 256

    //数据包中  数据占用的长度
    private var dataLength = 250

    private fun connect14551(){
        try {
            datagramSocket =  DatagramSocket(14551)
            datagramSocket?.connect(InetAddress.getByName("127.0.0.1"), 14552)
        } catch (e: Exception) {
            e.printStackTrace()
        }
        read14551()
    }

    private fun read14551(){
        try {
            while (datagramSocket != null) {
                var cache = ByteArray(256)
                var packet = DatagramPacket(cache , cache.size)
                datagramSocket?.receive(packet)
                //packet.length 是读取到的包长度
                var tempArray = ByteArray(packet.length)
                System.arraycopy( packet.data,0,tempArray,0,packet.length)
                Log.e(TAG,"收到：${String2ByteArrayUtils.bytes2Hex(tempArray)}")
                dataDeal(tempArray)
            }
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }

    private fun dataDeal(datas:ByteArray){

        //如果缓存数组不足 256字节  直接存入
        if(cacheByteArrayIndex < packageLength){
            System.arraycopy(datas,0,cacheByteArray,cacheByteArrayIndex,datas.size)
            cacheByteArrayIndex += datas.size
            return
        }

        //当前index + 数组长度 大于 缓存数字的长度 缓存数组放不下了
        if(cacheByteArrayIndex + datas.size > cacheByteArrayLength){
            //保存最后256字节
            var tempByteArray = ByteArray(cacheByteArrayLength)
            System.arraycopy(cacheByteArray,cacheByteArrayIndex - packageLength,tempByteArray,0,packageLength)
            cacheByteArrayIndex = packageLength
            cacheByteArray = tempByteArray
        }

        //copy datas数组到  cacheByteArray
        System.arraycopy(datas,0,cacheByteArray,cacheByteArrayIndex,datas.size)
        cacheByteArrayIndex += datas.size

        //在缓存数组中  找出头部 AT+
        var headArray = headStr.toByteArray()
        var s1 = String2ByteArrayUtils.bytes2Hex(cacheByteArray)
        var s2 = String2ByteArrayUtils.bytes2Hex(headArray)


        var startIndex = (s1?.indexOf(s2?:"")?:0) / 2
        var lastIndex = (s1?.lastIndexOf(   s2?:"")?:0) / 2


//        LogUtils.test("startIndex:${startIndex}")
//        LogUtils.test("lastIndex:${lastIndex}")

        //只有一个
        if(startIndex == lastIndex){
            //\r\n 的开始位置符  = headStr的 index + headStr的length + 编号 + 数据长度
            var endIndex = startIndex + headArray.size + 1 + dataLength
            //如果符合一个完整包的 指令结尾
            if(cacheByteArray[endIndex] == 0x0D.toByte() && cacheByteArray[endIndex + 1] == 0x0A.toByte()){
                //完整包 将数据移除缓存数组 并且移除完整包之前无用的数据
                var tempByteArray = ByteArray(cacheByteArrayLength)
                //copy 从 startIndex + packageLength 到 cacheByteArrayIndex - (startIndex + packageLength)之间数据到tempByteArray
                System.arraycopy(cacheByteArray,startIndex + packageLength,tempByteArray,0,cacheByteArrayIndex - (startIndex + packageLength))
                cacheByteArray = tempByteArray
                cacheByteArrayIndex -= (startIndex + packageLength)
            }else{
                LogUtils.test("错误包：${String2ByteArrayUtils.bytes2Hex(cacheByteArray)}")
                //错误包
                var idByte = cacheByteArray[startIndex + headArray.size ]
                //只有一个头并且数据长度都大于256 则全部是错误数据。第一包有编号  后续没有头编号只能丢弃  移除错误数据
                cacheByteArray = ByteArray(cacheByteArrayLength)
                cacheByteArrayIndex = 0
                send(idByte?.toChar())

                LogUtils.test("错误包2id：${idByte?.toChar()}")
            }
        }else{
            var endIndex = startIndex + headArray.size + 1 + dataLength
            //如果符合一个完整包的 指令结尾
            if(cacheByteArray[endIndex] == 0x0D.toByte() && cacheByteArray[endIndex + 1] == 0x0A.toByte()){
                //完整包 将数据移除缓存数组 并且移除完整包之前无用的数据
                var tempByteArray = ByteArray(cacheByteArrayLength)
                //copy 从 startIndex + packageLength 到 cacheByteArrayIndex - (startIndex + packageLength)之间数据到tempByteArray
                System.arraycopy(cacheByteArray,startIndex + packageLength,tempByteArray,0,cacheByteArrayIndex - (startIndex + packageLength))
                cacheByteArray = tempByteArray
                cacheByteArrayIndex -= (startIndex + packageLength)
            }else{
                LogUtils.test("错误包：${String2ByteArrayUtils.bytes2Hex(cacheByteArray)}")
                //错误包
                var idByte = cacheByteArray[startIndex + headArray.size ]
                //移除错误数据
                var tempByteArray = ByteArray(cacheByteArrayLength)
                System.arraycopy(cacheByteArray,lastIndex,tempByteArray,0,cacheByteArrayIndex - lastIndex)
                cacheByteArray = tempByteArray
                cacheByteArrayIndex -= cacheByteArrayIndex - lastIndex
                send(idByte?.toChar())
                LogUtils.test("错误包2id：${idByte?.toChar()}")
            }

        }

    }

    private fun send(id:Char){
        try {
            var packet = DatagramPacket( ByteArray(256), 256)
            packet.data =  "AT+ERR -n${id}".toByteArray()
            datagramSocket?.send(packet)
            Log.e(TAG,"发送：${String2ByteArrayUtils.bytes2Hex(packet.data)}")
        } catch (e: java.lang.Exception) {
            e.printStackTrace()
        }
    }
    //endregion



    override fun onDestroy() {
        super.onDestroy()
        datagramSocket?.close()
        datagramSocket2?.close()
    }
}